{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "#首先导入一些用到的库。\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-b0ffac263758>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\base.py:252: _internal_retry.<locals>.wrap.<locals>.wrapped_fn (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use urllib or similar directly.\n",
      "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n",
      "WARNING:tensorflow:From D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n",
      "WARNING:tensorflow:From D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000,)\n",
      "(5000, 784)\n",
      "(5000,)\n",
      "(10000, 784)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "#导入mnist数据集并查看数据的属性\n",
    "mnist = input_data.read_data_sets(\"./\")\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量， 所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。\n",
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4, idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(mnist.train.labels[idx]))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "#这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个float类型的变量用于设置学习率。\n",
    "#为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。\n",
    "x = tf.placeholder(\"float\", [None, 784])\n",
    "y = tf.placeholder(\"int64\", [None])\n",
    "learning_rate = tf.placeholder(\"float\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize(shape, stddev=0.1):\n",
    "  return tf.truncated_normal(shape, stddev=0.1)\n",
    "\n",
    "L1_units_count = 100\n",
    "\n",
    "W_1 = tf.Variable(initialize([784, L1_units_count]))\n",
    "b_1 = tf.Variable(initialize([L1_units_count]))\n",
    "logits_1 = tf.matmul(x, W_1) + b_1\n",
    "output_1 = tf.nn.relu(logits_1)\n",
    "\n",
    "L2_units_count = 10 \n",
    "W_2 = tf.Variable(initialize([L1_units_count, L2_units_count]))\n",
    "b_2 = tf.Variable(initialize([L2_units_count]))\n",
    "logits_2 = tf.matmul(output_1, W_2) + b_2  \n",
    "\n",
    "logits = logits_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits, 这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为可以根据需要设定。\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=learning_rate).minimize(cross_entropy_loss)\n",
    "#需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布， 要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。\n",
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), y)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#saver用于保存或恢复训练的模型。\n",
    "batch_size = 32\n",
    "trainig_step = 1000\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.272548, the validation accuracy is 0.8748\n",
      "after 200 training steps, the loss is 0.0568694, the validation accuracy is 0.9112\n",
      "after 300 training steps, the loss is 0.214749, the validation accuracy is 0.9284\n",
      "after 400 training steps, the loss is 0.390169, the validation accuracy is 0.9222\n",
      "after 500 training steps, the loss is 0.143972, the validation accuracy is 0.9456\n",
      "after 600 training steps, the loss is 0.177198, the validation accuracy is 0.9502\n",
      "WARNING:tensorflow:From D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:960: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps, the loss is 0.164404, the validation accuracy is 0.9526\n",
      "after 800 training steps, the loss is 0.154853, the validation accuracy is 0.942\n",
      "after 900 training steps, the loss is 0.224785, the validation accuracy is 0.952\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9514\n"
     ]
    }
   ],
   "source": [
    "#以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss = sess.run(\n",
    "            [optimizer, cross_entropy_loss],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                learning_rate: 0.3\n",
    "            })\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From D:\\Anaconda3\\envs\\tf1.14\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-900\n",
      "0.9375\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#下面，用我们训练的模型做一个测试。\n",
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16]\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(mnist.test.labels[idx],\n",
    "                                                  order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
